﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;
using System.IO.Compression;
using System.Net;
using System.Text.RegularExpressions;
using System.Xml.Linq;
using System.Diagnostics;
using Downloader;
using Update.Data.Enum;
using Update.Servers.Gitee;

/// <summary>
/// 更新服务器接口
/// </summary>
public interface IUpdateServer : IDisposable
{
    /// <summary>
    /// 获取服务器最新版本号
    /// </summary>
    /// <returns>版本号</returns>
    Task<string> GetServerVersionAsync();

    /// <summary>
    /// 获取更新日志
    /// </summary>
    /// <returns>更新日志内容</returns>
    Task<string> GetChangelogAsync();

    /// <summary>
    /// 获取下载地址
    /// </summary>
    /// <param name="version">版本号</param>
    /// <returns>下载地址</returns>
    Task<string> GetDownloadUrlAsync(string version);
}

namespace Update.UI
{
    public partial class FrmMain : Form
    {
        #region 成员变量
        // 服务器和版本相关
        private ServerType serverType = ServerType.Standard;
        private string targetAppPath;
        private string targetAppExe;
        private string configFile = "UpdateConfig.xml";
        private string updatePackagePath;
        private string localVersion;
        private string serverVersion;
        private string updateLog;

        // 更新选项
        private bool silentUpdate = false;
        private bool forceOverwrite = true;
        private bool autoTerminateProcesses = true;
        private IUpdateServer updateServer;

        // 下载客户端
        private DownloadService downloader;
        private DownloadConfiguration downloadConfig;

        #endregion

        #region 构造函数
        /// <summary>
        /// 默认构造函数
        /// </summary>
        public FrmMain()
        {
            try
            {
                InitializeComponent();
                InitializeDownloader();
            }
            catch (Exception ex)
            {
                MessageBox.Show($"初始化界面失败: {ex.Message}\n\n{ex.StackTrace}",
                    "初始化错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 带版本参数的构造函数
        /// </summary>
        /// <param name="version">本地版本号</param>
        public FrmMain(string version)
        {
            try
            {
                InitializeComponent();
                InitializeDownloader();

                // 设置本地版本号
                localVersion = version;
            }
            catch (Exception ex)
            {
                MessageBox.Show($"初始化界面失败: {ex.Message}\n\n{ex.StackTrace}",
                    "初始化错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
        #endregion

        #region 初始化方法
        /// <summary>
        /// 初始化下载器
        /// </summary>
        private void InitializeDownloader()
        {
            try
            {
                // 创建下载配置
                downloadConfig = new DownloadConfiguration
                {
                    BufferBlockSize = 10240, // 缓冲区大小
                    ChunkCount = 8,          // 分块数
                    MaximumBytesPerSecond = 0, // 不限制下载速度
                    MaxTryAgainOnFailover = 5, // 失败重试次数
                    ParallelDownload = true, // 启用并行下载
                    Timeout = 5000,          // 超时时间
                    RequestConfiguration = {
                        Accept = "*/*",
                        AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate,
                        UseDefaultCredentials = false,
                        KeepAlive = false
                    }
                };

                // 创建下载服务
                downloader = new DownloadService(downloadConfig);

                // 注册事件处理
                downloader.DownloadProgressChanged += Downloader_ProgressChanged;
                downloader.DownloadFileCompleted += Downloader_DownloadFileCompleted;

                LogMessage("下载器初始化完成");
            }
            catch (Exception ex)
            {
                LogMessage($"初始化下载器失败: {ex.Message}");
                throw;
            }
        }
        #endregion

        #region 窗体事件
        private void FrmMain_Load(object sender, EventArgs e)
        {
            try
            {
                // 禁用按钮，直到配置加载完成
                btnStartUpdate.Enabled = false;
                btnExit.Enabled = false;
                btnCheckUpdate.Enabled = false;

                // 设置窗体标题，显示更新器版本
                this.Text = $"应用程序更新 - v{Program.UpdaterVersion}";


                // 记录版本信息
                LogMessage($"更新器版本: v{Program.UpdaterVersion}");

                // 确保所有控件可见
                btnStartUpdate.Visible = true;
                btnExit.Visible = true;
                btnCheckUpdate.Visible = true;

                // 初始状态下隐藏进度条，仅在此处隐藏，后续更新过程中不再隐藏
                progressBar.Visible = false;
                lblDownloadProgress.Visible = false;

                // 默认只显示更新日志，隐藏详细日志
                txtUpdateLog.Visible = true;
                txtLog.Visible = false;

                // 初始化更新日志内容
                txtUpdateLog.Text = "正在检查更新...";

                // 检查更新器自身是否需要更新
                CheckUpdaterSelfUpdate();

                // 加载配置文件
                LoadConfiguration();

                // 启用退出按钮
                btnExit.Enabled = true;

                // 将窗口置顶显示
                this.TopMost = true;

                // 自动启动更新检查
                StartUpdate();

                // 延迟2秒后取消置顶，避免长时间阻挡其他窗口
                Timer topMostTimer = new Timer();
                topMostTimer.Interval = 2000; // 2秒
                topMostTimer.Tick += (s, args) =>
                {
                    this.TopMost = false;
                    topMostTimer.Stop();
                    topMostTimer.Dispose();
                };
                topMostTimer.Start();
            }
            catch (Exception ex)
            {
                LogMessage($"初始化失败: {ex.Message}");
                MessageBox.Show($"初始化失败: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                btnExit.Enabled = true;
            }
        }

        /// <summary>
        /// 释放资源
        /// </summary>
        private void OnFormClosing(object sender, FormClosingEventArgs e)
        {


            // 释放下载器资源
            if (downloader != null)
            {
                downloader.Dispose();
            }

            // 释放更新服务器资源
            if (updateServer != null && updateServer is IDisposable disposable)
            {
                disposable.Dispose();
            }
        }
        #endregion

        #region 配置加载
        /// <summary>
        /// 加载配置文件
        /// </summary>
        private void LoadConfiguration()
        {
            try
            {
                LogMessage("正在加载配置...");

                // 读取配置文件
                if (!File.Exists(configFile))
                {
                    // 配置文件不存在的情况已在Program.cs中处理
                    // 这里只需记录日志并返回
                    LogMessage("错误: 配置文件不存在，程序将退出");
                    btnExit.Enabled = true;
                    return;
                }

                XDocument doc = XDocument.Load(configFile);
                var config = doc.Root;

                // 读取服务器类型
                string serverTypeStr = config.Element("ServerType")?.Value;
                if (string.IsNullOrEmpty(serverTypeStr))
                {
                    throw new InvalidOperationException("配置文件中未指定服务器类型");
                }

                if (!Enum.TryParse(serverTypeStr, true, out ServerType type))
                {
                    throw new InvalidOperationException($"不支持的服务器类型: {serverTypeStr}");
                }

                serverType = type;
                LogMessage($"服务器类型: {serverType}");

                // 获取应用程序配置
                var appConfig = UpdateServerFactory.GetApplicationConfig(doc);
                if (appConfig == null)
                {
                    throw new InvalidOperationException("配置文件中未找到应用程序配置");
                }

                // 读取应用程序配置
                targetAppPath = appConfig.Element("TargetPath")?.Value ?? ".";
                targetAppExe = appConfig.Element("ExeName")?.Value;

                // 只有在构造函数没有设置本地版本的情况下，才从配置文件读取
                if (string.IsNullOrEmpty(localVersion))
                {
                    localVersion = appConfig.Element("LocalVersion")?.Value;

                    // 如果配置文件中也没有指定本地版本，尝试从version.txt中读取
                    if (string.IsNullOrEmpty(localVersion))
                    {
                        string versionFile = Path.Combine(targetAppPath, "version.txt");
                        if (File.Exists(versionFile))
                        {
                            localVersion = File.ReadAllText(versionFile).Trim();
                        }
                    }
                }

                LogMessage($"本地版本: {localVersion}");

                // 创建服务器实例
                updateServer = UpdateServerFactory.CreateServer(serverTypeStr, doc);

                // 获取静默更新设置
                LoadUpdateOptions(doc);

                LogMessage($"静默更新: {(silentUpdate ? "是" : "否")}");

                // 根据静默更新设置，更新UI
                btnStartUpdate.Enabled = !silentUpdate;
            }
            catch (Exception ex)
            {
                LogMessage($"加载配置失败: {ex.Message}");
                MessageBox.Show($"加载配置文件失败: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 加载更新选项
        /// </summary>
        /// <param name="doc">配置文档</param>
        private void LoadUpdateOptions(XDocument doc)
        {
            try
            {
                // 读取静默更新设置
                string silentUpdateStr = doc.Root?.Element("SilentUpdate")?.Value ?? "false";
                if (bool.TryParse(silentUpdateStr, out bool silent))
                {
                    silentUpdate = silent;
                }

                // 读取强制覆盖设置
                string forceOverwriteStr = doc.Root?.Element("ForceOverwrite")?.Value ?? "false";
                if (bool.TryParse(forceOverwriteStr, out bool force))
                {
                    forceOverwrite = force;
                }

                // 读取自动终止进程设置
                string autoTerminateStr = doc.Root?.Element("AutoTerminateProcesses")?.Value ?? "false";
                if (bool.TryParse(autoTerminateStr, out bool autoTerminate))
                {
                    autoTerminateProcesses = autoTerminate;
                }

                LogMessage($"静默更新: {silentUpdate}");
                LogMessage($"强制覆盖: {forceOverwrite}");
                LogMessage($"自动终止进程: {autoTerminateProcesses}");
            }
            catch (Exception ex)
            {
                LogMessage($"加载更新选项失败: {ex.Message}");
            }
        }
        #endregion

        #region 更新检查和下载
        /// <summary>
        /// 开始更新检查
        /// </summary>
        private async void StartUpdate()
        {
            // 直接异步执行更新检查
            await CheckForUpdatesAsync();
        }

        /// <summary>
        /// 检查更新
        /// </summary>
        private async Task CheckForUpdatesAsync()
        {
            try
            {
                txtLog.Clear();
                LogMessage($"更新器版本: v{Program.UpdaterVersion}");
                LogMessage("开始检查更新...");

                // 获取服务器端版本
                LogMessage("正在获取服务器端版本...");
                try
                {
                    // 禁用界面按钮，避免用户重复点击
                    if (btnExit.InvokeRequired)
                    {
                        this.Invoke(new Action(() => btnExit.Enabled = false));
                    }
                    else
                    {
                        btnExit.Enabled = false;
                    }

                    serverVersion = updateServer.GetServerVersion();
                    if (string.IsNullOrEmpty(serverVersion))
                    {
                        throw new Exception("获取到的服务器版本为空");
                    }
                }
                catch (Exception ex)
                {
                    // 记录详细的错误信息
                    LogMessage($"获取服务器版本出错: {ex.Message}");
                    if (ex.InnerException != null)
                    {
                        LogMessage($"内部错误: {ex.InnerException.Message}");
                    }

                    LogMessage("无法获取服务器版本");

                    // 如果无法获取版本，显示提示并退出
                    if (!silentUpdate)
                    {
                        // 重新启用退出按钮
                        if (btnExit.InvokeRequired)
                        {
                            this.Invoke(new Action(() => btnExit.Enabled = true));
                        }
                        else
                        {
                            btnExit.Enabled = true;
                        }

                        MessageBox.Show("无法获取服务器版本信息，请检查网络连接或稍后再试。\n\n" +
                            $"错误详情: {ex.Message}", "更新失败",
                            MessageBoxButtons.OK, MessageBoxIcon.Error);
                        Application.Exit();
                    }
                    return;
                }

                // 重新启用退出按钮
                if (btnExit.InvokeRequired)
                {
                    this.Invoke(new Action(() => btnExit.Enabled = true));
                }
                else
                {
                    btnExit.Enabled = true;
                }

                LogMessage($"服务器版本: {serverVersion}");

                // 获取更新日志
                GetChangelog();

                // 比较版本
                LogMessage("正在比较版本...");
                int compareResult = VersionHelper.CompareVersion(serverVersion, localVersion);

                if (compareResult <= 0)
                {
                    HandleNoUpdateNeeded();
                    return;
                }

                // 有新版本可用
                await HandleUpdateAvailable();

                // 如果是静默更新模式，直接开始更新
                if (silentUpdate)
                {
                    await PerformSilentUpdate();
                }
                else
                {
                    // 非静默模式下启用开始更新按钮
                    EnableStartUpdateButton();

                    // 非静默模式，检查目标程序是否正在运行
                    if (IsTargetApplicationRunning())
                    {
                        await HandleRunningApplication();
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessage($"更新过程中发生错误: {ex.Message}");

                // 确保按钮都被启用
                if (InvokeRequired)
                {
                    this.Invoke(new Action(() =>
                    {
                        btnExit.Enabled = true;
                        btnStartUpdate.Enabled = true;
                    }));
                }
                else
                {
                    btnExit.Enabled = true;
                    btnStartUpdate.Enabled = true;
                }
            }
        }

        /// <summary>
        /// 获取更新日志
        /// </summary>
        private string GetChangelog()
        {
            try
            {
                // 检查服务器是否支持更新日志
                if (updateServer is GiteeServer giteeServer && giteeServer.SupportsChangelog)
                {
                    LogMessage("正在获取更新日志...");
                    updateLog = updateServer.GetChangelog(serverVersion);

                    if (!string.IsNullOrEmpty(updateLog))
                    {
                        LogMessage("更新日志获取成功");

                        // 更新UI
                        txtUpdateLog.Text = updateLog;
                    }
                    else
                    {
                        LogMessage("未找到更新日志");
                    }
                }
                else
                {
                    LogMessage("当前服务器不支持更新日志");
                }

                return updateLog;
            }
            catch (Exception ex)
            {
                LogMessage($"获取更新日志失败: {ex.Message}");
                return string.Empty;
            }
        }

        /// <summary>
        /// 处理无需更新的情况
        /// </summary>
        private void HandleNoUpdateNeeded()
        {
            LogMessage("当前已是最新版本，无需更新");

            // 当前已是最新版本，显示提示并退出
            if (!silentUpdate)
            {
                // 确保消息框显示在更新器窗口之上
                this.TopMost = false;
                MessageBox.Show($"当前版本 {localVersion} 已是最新版本，无需更新。",
                    "已是最新版本", MessageBoxButtons.OK, MessageBoxIcon.Information);
                Application.Exit();
            }
            else
            {
                // 静默模式下也需要退出
                Application.Exit();
            }
        }

        /// <summary>
        /// 处理有更新可用的情况
        /// </summary>
        private async Task HandleUpdateAvailable()
        {
            try
            {
                LogMessage($"发现新版本: {serverVersion}，当前版本: {localVersion}");
                txtUpdateLog.AppendText($"\r\n发现新版本: {serverVersion}，当前版本: {localVersion}\r\n");
                // 获取更新日志
                updateLog = GetChangelog();

                // 显示更新日志
                if (!string.IsNullOrEmpty(updateLog))
                {
                    txtUpdateLog.AppendText($"\r\n{updateLog}");
                }
                else
                {
                    txtUpdateLog.AppendText("\r\n无更新日志");
                }

                // 启用开始更新按钮
                EnableStartUpdateButton();

                // 如果是静默更新模式，直接开始更新
                if (silentUpdate)
                {
                    await PerformSilentUpdate();
                }
            }
            catch (Exception ex)
            {
                LogMessage($"处理更新时出错: {ex.Message}");
            }
        }

        /// <summary>
        /// 执行静默更新
        /// </summary>
        private async Task PerformSilentUpdate()
        {
            try
            {
                LogMessage("开始执行静默更新...");

                // 创建更新信息对象
                UpdateInfo updateInfo = new UpdateInfo
                {
                    Version = serverVersion,
                    Changelog = updateLog
                };

                // 下载更新包
                updatePackagePath = await DownloadUpdatePackage(updateInfo);

                if (string.IsNullOrEmpty(updatePackagePath) || !File.Exists(updatePackagePath))
                {
                    throw new Exception("下载更新包失败");
                }

                LogMessage("更新包下载完成");

                // 安装更新
                await Task.Run(() => InstallUpdate());

                // 重启应用
                LogMessage("更新完成，准备重启应用...");

                // 短暂延迟以确保UI更新
                await Task.Delay(200);

                RestartApplication();
            }
            catch (Exception ex)
            {
                LogMessage($"静默更新失败: {ex.Message}");

                // 确保消息框显示在前面
                this.TopMost = false;

                if (!silentUpdate)
                {
                    MessageBox.Show($"更新失败: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
        }

        /// <summary>
        /// 启用"开始更新"按钮
        /// </summary>
        private void EnableStartUpdateButton()
        {
            if (btnStartUpdate.InvokeRequired)
            {
                btnStartUpdate.Invoke(new Action(EnableStartUpdateButton));
            }
            else
            {
                btnStartUpdate.Enabled = true;
            }
        }

        /// <summary>
        /// 处理目标应用程序正在运行的情况
        /// </summary>
        private async Task HandleRunningApplication()
        {
            DialogResult result = MessageBox.Show(
                $"检测到 {Path.GetFileNameWithoutExtension(targetAppExe)} 正在运行。\n\n需要关闭它才能进行更新，是否立即关闭并更新？",
                "应用程序正在运行",
                MessageBoxButtons.YesNo,
                MessageBoxIcon.Question);

            if (result == DialogResult.Yes)
            {
                // 用户选择关闭应用程序
                if (TerminateProcessesUsingFile(Path.Combine(targetAppPath, targetAppExe)))
                {
                    LogMessage("已关闭目标程序，继续更新");
                    // 等待进程完全结束
                    await Task.Delay(500);
                }
                else
                {
                    LogMessage("无法自动关闭目标程序，请手动关闭后再更新");
                    MessageBox.Show("无法自动关闭应用程序，请手动关闭后再尝试更新。",
                        "无法关闭应用", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
            }
            else
            {
                // 用户选择不关闭应用程序
                LogMessage("用户取消，更新已中止");
            }
        }

        /// <summary>
        /// 下载更新包
        /// </summary>
        /// <param name="updateInfo">更新信息</param>
        /// <returns>更新包本地路径</returns>
        private async Task<string> DownloadUpdatePackage(UpdateInfo updateInfo)
        {
            try
            {
                LogMessage($"开始下载更新包 v{updateInfo.Version}");

                // 创建临时目录
                string tempDir = Path.Combine(Path.GetTempPath(), "AppUpdater");
                if (!Directory.Exists(tempDir))
                {
                    Directory.CreateDirectory(tempDir);
                }

                // 设置下载文件路径
                string fileName = $"update_{updateInfo.Version}_{DateTime.Now.ToString("yyyyMMddHHmmss")}.zip";
                string filePath = Path.Combine(tempDir, fileName);

                // 显示进度条
                ShowProgressBar(0);

                LogMessage($"正在下载更新包 v{updateInfo.Version}");

                // 使用IUpdateServer接口的DownloadUpdatePackage方法
                string downloadedPath = await Task.Run(() => updateServer.DownloadUpdatePackage(
                    updateInfo.Version,
                    filePath,
                    (progress, speed, message) =>
                    {
                        // 使用ReportProgress方法更新UI
                        ReportProgress(progress, message, speed);
                    }
                ));

                // 检查文件是否下载成功
                if (string.IsNullOrEmpty(downloadedPath) || !File.Exists(downloadedPath))
                {
                    throw new Exception("下载更新包失败");
                }

                // 确保进度条显示100%
                ReportProgress(100, "下载完成，准备安装...");

                LogMessage("更新包下载完成");
                return downloadedPath;
            }
            catch (Exception ex)
            {
                LogMessage($"下载更新包失败: {ex.Message}");
                throw;
            }
        }

        /// <summary>
        /// 显示进度条
        /// </summary>
        /// <param name="value">初始值</param>
        private void ShowProgressBar(int value)
        {
            if (progressBar.InvokeRequired)
            {
                progressBar.Invoke(new Action<int>(ShowProgressBar), value);
            }
            else
            {
                progressBar.Value = Math.Min(100, Math.Max(0, value));
                progressBar.Visible = true;
                lblDownloadProgress.Visible = true;
                lblDownloadProgress.Text = $"{value}%";
            }
        }

        /// <summary>
        /// 隐藏进度条
        /// </summary>
        private void HideProgressBar()
        {
            if (progressBar.InvokeRequired)
            {
                progressBar.Invoke(new Action(HideProgressBar));
            }
            else
            {
                progressBar.Visible = false;
                lblDownloadProgress.Visible = false;
            }
        }

        /// <summary>
        /// 更新进度条
        /// </summary>
        /// <param name="progressValue">进度值(0-100)</param>
        /// <param name="message">进度消息</param>
        /// <param name="speed">下载速度(KB/s)</param>
        private void ReportProgress(int progressValue, string message, double speed = 0)
        {
            try
            {
                // 确保进度值在0-100之间
                int value = Math.Min(100, Math.Max(0, progressValue));

                // 更新进度条
                if (progressBar.InvokeRequired)
                {
                    progressBar.Invoke(new Action<int, string, double>(ReportProgress), value, message, speed);
                }
                else
                {
                    progressBar.Value = value;

                    // 如果提供了速度信息，则在进度文本中显示
                    if (speed > 0)
                    {
                        string speedUnit = "KB/s";
                        if (speed > 1024)
                        {
                            speed /= 1024;
                            speedUnit = "MB/s";
                        }
                        lblDownloadProgress.Text = $"{value}% ({speed:F2} {speedUnit})";
                    }
                    else
                    {
                        lblDownloadProgress.Text = $"{value}%";
                    }

                    // 记录日志
                    LogMessage(message);
                }
            }
            catch (Exception ex)
            {
                LogMessage($"更新进度条时出错: {ex.Message}");
            }
        }

        /// <summary>
        /// 下载进度变更事件处理
        /// </summary>
        private void Downloader_ProgressChanged(object sender, Downloader.DownloadProgressChangedEventArgs e)
        {
            // 注意：此方法现在仅用于更新器自身的更新下载
            try
            {
                // 计算下载速度
                double speed = e.BytesPerSecondSpeed / 1024.0;
                string speedUnit = "KB/s";

                if (speed > 1024)
                {
                    speed /= 1024.0;
                    speedUnit = "MB/s";
                }

                // 计算已下载大小
                double downloaded = e.ReceivedBytesSize / 1024.0;
                string downloadedUnit = "KB";

                if (downloaded > 1024)
                {
                    downloaded /= 1024.0;
                    downloadedUnit = "MB";
                }

                // 计算总大小
                double total = e.TotalBytesToReceive / 1024.0;
                string totalUnit = "KB";

                if (total > 1024)
                {
                    total /= 1024.0;
                    totalUnit = "MB";
                }

                // 更新进度
                int progressPercentage = (int)e.ProgressPercentage;
                ReportProgress(progressPercentage, $"下载更新器更新: {progressPercentage}% ({downloaded:F2} {downloadedUnit}/{total:F2} {totalUnit}, {speed:F2} {speedUnit})");
            }
            catch (Exception ex)
            {
                LogMessage($"处理下载进度事件时出错: {ex.Message}");
            }
        }

        /// <summary>
        /// 下载完成事件处理
        /// </summary>
        private void Downloader_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
        {
            // 注意：此方法现在仅用于更新器自身的更新下载
            try
            {
                if (e.Cancelled)
                {
                    LogMessage("下载已取消");
                }
                else if (e.Error != null)
                {
                    LogMessage($"下载失败: {e.Error.Message}");
                }
                else
                {
                    LogMessage("下载完成");
                }
            }
            catch (Exception ex)
            {
                LogMessage($"处理下载完成事件时出错: {ex.Message}");
            }
        }
        #endregion

        #region 安装和应用程序管理
        /// <summary>
        /// 安装更新
        /// </summary>
        private void InstallUpdate()
        {
            try
            {
                // 确保目标目录存在
                if (!Directory.Exists(targetAppPath))
                {
                    Directory.CreateDirectory(targetAppPath);
                }

                // 确保更新包存在且可访问
                if (string.IsNullOrEmpty(updatePackagePath))
                {
                    throw new Exception("更新包路径未指定");
                }

                if (!File.Exists(updatePackagePath))
                {
                    throw new Exception($"更新包文件不存在: {updatePackagePath}");
                }

                // 解压更新包
                LogMessage("正在解压更新包...");
                // 更新进度信息


                // 解压文件
                try
                {
                    LogMessage("开始解压文件...");

                    // 使用自定义方法进行解压，而不是直接使用ZipFile.ExtractToDirectory
                    ExtractZipFileWithOverwrite(updatePackagePath, targetAppPath);

                    LogMessage("文件解压完成");
                    // 更新进度信息

                    // 更新版本信息文件
                    try
                    {
                        string versionFilePath = Path.Combine(targetAppPath, "version.txt");
                        File.WriteAllText(versionFilePath, serverVersion);
                    }
                    catch (Exception ex)
                    {
                        LogMessage($"[警告] 更新版本文件失败: {ex.Message}");
                    }
                }
                catch (Exception ex)
                {
                    LogMessage($"解压文件失败: {ex.Message}");
                    throw;
                }

                LogMessage("更新包安装完成");
            }
            catch (Exception ex)
            {
                throw new Exception("安装更新失败: " + ex.Message);
            }
        }

        /// <summary>
        /// 解压ZIP文件并覆盖现有文件，处理文件占用情况
        /// </summary>
        /// <param name="zipFilePath">ZIP文件路径</param>
        /// <param name="destinationPath">目标路径</param>
        private void ExtractZipFileWithOverwrite(string zipFilePath, string destinationPath)
        {
            using (ZipArchive archive = ZipFile.OpenRead(zipFilePath))
            {
                int totalFiles = archive.Entries.Count;
                int processedFiles = 0;

                // 记录处理跳过的文件
                List<string> skippedFiles = new List<string>();

                foreach (ZipArchiveEntry entry in archive.Entries)
                {
                    processedFiles++;

                    // 跳过目录项
                    if (string.IsNullOrEmpty(entry.Name))
                    {
                        continue;
                    }

                    string destinationFilePath = Path.Combine(destinationPath, entry.FullName);
                    string destinationDirectory = Path.GetDirectoryName(destinationFilePath);

                    // 确保目标目录存在
                    if (!Directory.Exists(destinationDirectory))
                    {
                        Directory.CreateDirectory(destinationDirectory);
                    }

                    // 尝试提取文件
                    try
                    {
                        // 如果文件已存在，先删除它
                        if (File.Exists(destinationFilePath))
                        {
                            try
                            {
                                File.Delete(destinationFilePath);
                            }
                            catch (IOException)
                            {
                                // 文件被占用，尝试检查进程并询问用户
                                if (IsFileInUse(destinationFilePath))
                                {
                                    LogMessage($"文件被占用: {destinationFilePath}");

                                    // 根据设置决定是否自动结束进程
                                    if (autoTerminateProcesses)
                                    {
                                        LogMessage("尝试自动结束占用进程...");
                                        if (TerminateProcessesUsingFile(destinationFilePath))
                                        {
                                            // 重新尝试删除文件
                                            System.Threading.Thread.Sleep(500); // 等待进程完全结束
                                            try
                                            {
                                                File.Delete(destinationFilePath);
                                            }
                                            catch
                                            {
                                                LogMessage($"删除文件失败");
                                                skippedFiles.Add(entry.FullName);
                                                continue;
                                            }
                                        }
                                        else
                                        {
                                            // 如果无法结束进程，且强制覆盖选项开启，则询问用户
                                            if (forceOverwrite)
                                            {
                                                // 在UI线程上执行询问用户的操作
                                                bool userWantsToSkip = false;
                                                this.Invoke(new Action(() =>
                                                {
                                                    userWantsToSkip = MessageBox.Show(
                                                        $"文件 {Path.GetFileName(destinationFilePath)} 被占用且无法自动结束进程。\n\n是否跳过此文件继续更新？",
                                                        "文件被占用",
                                                        MessageBoxButtons.YesNo,
                                                        MessageBoxIcon.Question) == DialogResult.Yes;
                                                }));

                                                if (userWantsToSkip)
                                                {
                                                    LogMessage($"用户选择跳过更新此文件: {destinationFilePath}");
                                                    skippedFiles.Add(entry.FullName);
                                                    continue;
                                                }
                                                else
                                                {
                                                    throw new Exception($"无法更新被占用的文件: {destinationFilePath}");
                                                }
                                            }
                                            else
                                            {
                                                // 如果不强制覆盖，则跳过此文件
                                                LogMessage($"跳过被占用的文件: {destinationFilePath}");
                                                skippedFiles.Add(entry.FullName);
                                                continue;
                                            }
                                        }
                                    }
                                    else
                                    {
                                        // 如果不自动结束进程，询问用户是否手动结束
                                        bool terminateProcess = false;
                                        this.Invoke(new Action(() =>
                                        {
                                            terminateProcess = MessageBox.Show(
                                                $"文件 {Path.GetFileName(destinationFilePath)} 被占用，是否结束相关进程并继续更新？",
                                                "文件被占用",
                                                MessageBoxButtons.YesNo,
                                                MessageBoxIcon.Question) == DialogResult.Yes;
                                        }));

                                        if (terminateProcess)
                                        {
                                            // 尝试结束占用文件的进程
                                            if (TerminateProcessesUsingFile(destinationFilePath))
                                            {
                                                // 重新尝试删除文件
                                                System.Threading.Thread.Sleep(500); // 等待进程完全结束
                                                try
                                                {
                                                    File.Delete(destinationFilePath);
                                                }
                                                catch
                                                {
                                                    LogMessage($"删除文件失败");
                                                    skippedFiles.Add(entry.FullName);
                                                    continue;
                                                }
                                            }
                                            else
                                            {
                                                LogMessage($"无法结束占用进程，跳过文件: {destinationFilePath}");
                                                skippedFiles.Add(entry.FullName);
                                                continue;
                                            }
                                        }
                                        else
                                        {
                                            // 用户选择不结束进程，跳过此文件
                                            LogMessage($"用户选择跳过更新此文件: {destinationFilePath}");
                                            skippedFiles.Add(entry.FullName);
                                            continue;
                                        }
                                    }
                                }
                            }
                        }

                        // 提取文件
                        if (processedFiles % 10 == 0)
                        {
                            LogMessage($"正在解压文件 ({processedFiles}/{totalFiles}): {entry.FullName}");
                        }

                        // 创建文件流并复制内容
                        using (Stream entryStream = entry.Open())
                        using (FileStream fileStream = new FileStream(destinationFilePath, FileMode.Create, FileAccess.Write, FileShare.None))
                        {
                            entryStream.CopyTo(fileStream);
                        }
                    }
                    catch (Exception ex)
                    {
                        // 记录错误但继续处理其他文件
                        LogMessage($"解压文件失败: {entry.FullName}, 错误: {ex.Message}");
                        skippedFiles.Add(entry.FullName);
                    }
                }

                // 如果有跳过的文件，通知用户
                if (skippedFiles.Count > 0)
                {
                    LogMessage($"更新过程中有 {skippedFiles.Count} 个文件被跳过");
                }
            }
        }

        /// <summary>
        /// 检查文件是否被占用
        /// </summary>
        /// <param name="filePath">文件路径</param>
        /// <returns>是否被占用</returns>
        private bool IsFileInUse(string filePath)
        {
            try
            {
                using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
                {
                    // 如果能够以独占方式打开文件，则文件未被占用
                    return false;
                }
            }
            catch (IOException)
            {
                // 如果抛出IOException，文件可能被占用
                return true;
            }
            catch
            {
                // 其他异常，为安全起见返回false
                return false;
            }
        }

        /// <summary>
        /// 结束占用文件的进程
        /// </summary>
        /// <param name="filePath">文件路径</param>
        /// <returns>是否成功结束进程</returns>
        private bool TerminateProcessesUsingFile(string filePath)
        {
            try
            {
                // 使用handle.exe或其他工具获取占用进程的信息
                // 这里使用简化的方法，尝试结束目标应用程序进程
                string targetExeName = Path.GetFileNameWithoutExtension(targetAppExe);
                Process[] processes = Process.GetProcessesByName(targetExeName);

                if (processes.Length == 0)
                {
                    LogMessage($"找不到占用文件的进程: {targetExeName}");
                    return false;
                }

                foreach (Process process in processes)
                {
                    try
                    {
                        LogMessage($"正在结束进程: {process.ProcessName} (ID: {process.Id})");
                        process.Kill();
                        process.WaitForExit(2000); // 等待进程结束，最多2秒
                    }
                    catch (Exception ex)
                    {
                        LogMessage($"结束进程失败: {process.ProcessName}, 错误: {ex.Message}");
                        return false;
                    }
                }

                return true;
            }
            catch (Exception ex)
            {
                LogMessage($"查找占用进程失败: {ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 检查目标应用是否正在运行
        /// </summary>
        /// <returns>是否正在运行</returns>
        private bool IsTargetApplicationRunning()
        {
            if (string.IsNullOrEmpty(targetAppExe))
                return false;

            string processName = Path.GetFileNameWithoutExtension(targetAppExe);
            Process[] processes = Process.GetProcessesByName(processName);
            return processes.Length > 0;
        }

        /// <summary>
        /// 重启应用程序
        /// </summary>
        private void RestartApplication()
        {
            try
            {
                if (!string.IsNullOrEmpty(targetAppExe))
                {
                    string exePath = Path.Combine(targetAppPath, targetAppExe);

                    if (File.Exists(exePath))
                    {
                        // 更新进度信息，表示更新完成
                        ReportProgress(100, "更新完成，正在启动应用...");

                        // 短暂延迟以确保UI更新
                        System.Threading.Thread.Sleep(200);

                        // 启动应用程序
                        var process = Process.Start(exePath);

                        // 启动主程序后关闭更新器
                        if (process != null)
                        {
                            LogMessage("主程序已启动，3秒后自动关闭更新器");

                            // 延迟3秒后关闭更新器，确保主程序有充足的时间启动
                            Timer closeTimer = new Timer();
                            closeTimer.Interval = 3000; // 3秒
                            closeTimer.Tick += (s, e) =>
                            {
                                closeTimer.Stop();
                                Application.Exit();
                            };
                            closeTimer.Start();
                        }
                    }
                    else
                    {
                        throw new Exception($"找不到目标程序: {exePath}");
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception("重启应用程序失败: " + ex.Message);
            }
        }
        #endregion

        #region 日志记录
        /// <summary>
        /// 记录日志消息
        /// </summary>
        /// <param name="message">日志消息</param>
        private void LogMessage(string message)
        {
            // 添加空引用检查
            if (txtLog == null) return;

            if (txtLog.InvokeRequired)
            {
                txtLog.Invoke(new Action<string>(LogMessage), message);
            }
            else
            {
                txtLog.AppendText($"[{DateTime.Now.ToString("HH:mm:ss")}] {message}{Environment.NewLine}");
                txtLog.ScrollToCaret();
            }
        }
        #endregion

        #region 更新器自更新
        /// <summary>
        /// 检查更新器自身是否需要更新
        /// </summary>
        private async void CheckUpdaterSelfUpdate()
        {
            try
            {


                // 获取仓库信息
                string owner = "Suendanny";
                string repo = "UpdateTools";

                LogMessage("正在检查更新器是否有新版本...");

                // 创建WebClient实例
                using (WebClient client = new WebClient())
                {
                    client.Encoding = Encoding.UTF8;

                    // 获取Gitee发布页面内容
                    string html = await client.DownloadStringTaskAsync($"https://gitee.com/{owner}/{repo}/releases/");

                    // 使用正则表达式匹配文件名和版本号
                    // 匹配格式为 Update-x.x.x.zip 的文件名
                    Regex fileRegex = new Regex(@"href=""([^""]*?/Update-(\d+\.\d+\.\d+)\.zip)""");
                    Match fileMatch = fileRegex.Match(html);

                    if (fileMatch.Success)
                    {
                        string downloadUrl = "https://gitee.com" + fileMatch.Groups[1].Value;
                        string latestVersion = fileMatch.Groups[2].Value;
                        LogMessage($"检测到更新器最新版本: v{latestVersion}");

                        // 比较版本号
                        if (VersionHelper.CompareVersion(latestVersion, Program.UpdaterVersion) > 0)
                        {
                            LogMessage($"发现更新器新版本: v{latestVersion}，当前版本: v{Program.UpdaterVersion}，开始自动更新...");

                            // 直接更新，不询问用户
                            await UpdateUpdaterSelf(downloadUrl);
                        }
                        else
                        {
                            LogMessage("更新器已是最新版本");
                        }
                    }
                    else
                    {
                        // 尝试使用旧的正则表达式匹配方式
                        Regex versionRegex = new Regex(@"<h2[^>]*>\s*<a[^>]*>v(\d+\.\d+\.\d+)</a>");
                        Match versionMatch = versionRegex.Match(html);

                        if (versionMatch.Success)
                        {
                            string latestVersion = versionMatch.Groups[1].Value;
                            LogMessage($"检测到更新器最新版本: v{latestVersion}");

                            // 比较版本号
                            if (VersionHelper.CompareVersion(latestVersion, Program.UpdaterVersion) > 0)
                            {
                                LogMessage($"发现更新器新版本: v{latestVersion}，当前版本: v{Program.UpdaterVersion}，开始自动更新...");

                                // 构建下载URL
                                string downloadUrl = $"https://gitee.com/{owner}/{repo}/releases/download/v{latestVersion}/Update-{latestVersion}.zip";

                                // 直接更新，不询问用户
                                await UpdateUpdaterSelf(downloadUrl);
                            }
                            else
                            {
                                LogMessage("更新器已是最新版本");
                            }
                        }
                        else
                        {
                            LogMessage("无法从Gitee获取最新版本信息");
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessage($"检查更新器更新失败: {ex.Message}");
            }
        }

        /// <summary>
        /// 更新更新器自身
        /// </summary>
        /// <param name="downloadUrl">下载地址</param>
        /// <returns>是否成功</returns>
        private async Task<bool> UpdateUpdaterSelf(string downloadUrl)
        {
            try
            {
                // 创建临时目录
                string tempDir = Path.Combine(Path.GetTempPath(), "UpdaterSelf");
                if (!Directory.Exists(tempDir))
                {
                    Directory.CreateDirectory(tempDir);
                }

                // 设置下载文件路径
                string fileName = Path.GetFileName(downloadUrl);
                string filePath = Path.Combine(tempDir, fileName);

                LogMessage($"开始下载更新器更新: {downloadUrl}");

                // 显示进度条
                ShowProgressBar(0);

                // 使用 Downloader 库下载文件
                await downloader.DownloadFileTaskAsync(downloadUrl, filePath);

                // 确保进度条显示100%
                ReportProgress(100, "更新器更新包下载完成，准备安装...");

                // 下载完成后，解压并替换自身
                if (File.Exists(filePath))
                {
                    // 解压文件
                    string extractDir = Path.Combine(tempDir, "extract");
                    if (Directory.Exists(extractDir))
                    {
                        Directory.Delete(extractDir, true);
                    }
                    Directory.CreateDirectory(extractDir);

                    // 解压缩
                    ZipFile.ExtractToDirectory(filePath, extractDir);

                    // 创建批处理文件进行替换
                    string batchFile = Path.Combine(tempDir, "update.bat");
                    string currentExe = Application.ExecutablePath;
                    string updateExe = Path.Combine(extractDir, Path.GetFileName(currentExe));

                    // 确保更新文件存在
                    if (!File.Exists(updateExe))
                    {
                        LogMessage("未找到更新器可执行文件");
                        return false;
                    }

                    // 检查系统环境，决定使用PowerShell还是批处理
                    bool usePowerShell = IsPowerShellAvailable();
                    string scriptFile;
                    
                    if (usePowerShell)
                    {
                        // 使用PowerShell脚本（支持中文路径）
                        scriptFile = Path.Combine(tempDir, "update.ps1");
                        
                        // 创建PowerShell脚本内容
                        StringBuilder psSb = new StringBuilder();
                        psSb.AppendLine("# 等待原进程退出");
                        psSb.AppendLine("Start-Sleep -Seconds 1");
                        psSb.AppendLine("# 复制更新文件");
                        psSb.AppendLine($"Copy-Item -Path \"{updateExe}\" -Destination \"{currentExe}\" -Force");
                        psSb.AppendLine("# 启动应用程序");
                        psSb.AppendLine($"Start-Process -FilePath \"{currentExe}\"");
                        psSb.AppendLine("# 删除临时脚本");
                        psSb.AppendLine($"Remove-Item -Path \"{scriptFile}\" -Force");

                        // 写入PowerShell脚本文件
                        File.WriteAllText(scriptFile, psSb.ToString(), Encoding.UTF8);
                        
                        LogMessage("使用PowerShell执行更新");
                    }
                    else
                    {
                        // 使用批处理文件（避免中文路径问题）
                        scriptFile = Path.Combine(tempDir, "update.bat");
                        
                        // 创建批处理内容，使用短文件名避免中文路径问题
                        StringBuilder batSb = new StringBuilder();
                        batSb.AppendLine("@echo off");
                        batSb.AppendLine("ping -n 2 127.0.0.1 > nul"); // 等待原进程退出
                        
                        // 使用短路径名称避免中文路径问题
                        string shortUpdateExe = GetShortPath(updateExe);
                        string shortCurrentExe = GetShortPath(currentExe);
                        string shortScriptFile = GetShortPath(scriptFile);
                        
                        batSb.AppendLine($"copy /Y \"{shortUpdateExe}\" \"{shortCurrentExe}\"");
                        batSb.AppendLine($"start \"\" \"{shortCurrentExe}\"");
                        batSb.AppendLine($"del /Q \"{shortScriptFile}\"");
                        batSb.AppendLine("exit");

                        // 写入批处理文件
                        File.WriteAllText(scriptFile, batSb.ToString());
                        
                        LogMessage("使用批处理执行更新");
                    }

                    // 更新进度信息
                    ReportProgress(100, "更新器更新准备就绪，重启应用中...");

                    // 启动脚本
                    Process process = new Process();
                    if (usePowerShell)
                    {
                        process.StartInfo.FileName = "powershell.exe";
                        process.StartInfo.Arguments = $"-ExecutionPolicy Bypass -File \"{scriptFile}\"";
                    }
                    else
                    {
                        process.StartInfo.FileName = scriptFile;
                    }
                    process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
                    process.StartInfo.CreateNoWindow = true;
                    process.Start();

                    // 退出当前进程
                    Application.Exit();
                    return true;
                }
                else
                {
                    LogMessage("下载更新器更新失败");
                    return false;
                }
            }
            catch (Exception ex)
            {
                LogMessage($"更新更新器自身失败: {ex.Message}");
                return false;
            }
        }
        #endregion

        #region UI事件处理
        /// <summary>
        /// 开始更新按钮点击事件
        /// </summary>
        private async void btnStartUpdate_Click(object sender, EventArgs e)
        {
            try
            {
                // 禁用按钮，避免重复点击
                btnStartUpdate.Enabled = false;

                LogMessage("开始更新...");

                if (!string.IsNullOrEmpty(serverVersion))
                {
                    try
                    {
                        // 创建更新信息对象
                        UpdateInfo updateInfo = new UpdateInfo
                        {
                            Version = serverVersion,
                            Changelog = updateLog
                        };

                        // 下载更新包
                        updatePackagePath = await DownloadUpdatePackage(updateInfo);

                        if (string.IsNullOrEmpty(updatePackagePath) || !File.Exists(updatePackagePath))
                        {
                            throw new Exception("下载更新包失败");
                        }

                        LogMessage("更新包下载完成");

                        // 异步执行安装更新
                        await Task.Run(() => InstallUpdate());

                        // 重启应用
                        LogMessage("正在重启应用...");
                        LogMessage("更新完成，准备重启应用...");

                        // 短暂延迟以确保UI更新
                        await Task.Delay(200);

                        RestartApplication();

                        // 记录更新成功
                        LogMessage("更新成功！");
                    }
                    finally
                    {
                        btnStartUpdate.Enabled = true;
                    }
                }
                else
                {
                    LogMessage("更新失败：未获取到服务器版本信息");
                }
            }
            catch (Exception ex)
            {
                LogMessage($"更新过程中发生错误: {ex.Message}");

                // 确保消息框显示在前面
                this.TopMost = false;

                MessageBox.Show($"更新失败: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 检查更新按钮点击事件
        /// </summary>
        private async void btnCheckUpdate_Click(object sender, EventArgs e)
        {
            try
            {
                LogMessage("开始检查更新...");

                // 禁用按钮，避免重复点击
                btnCheckUpdate.Enabled = false;

                // 执行更新检查
                await CheckForUpdatesAsync();

                if (VersionHelper.CompareVersion(serverVersion, localVersion) > 0)
                {
                    // 有新版本可用，显示更新内容
                    LogMessage($"发现新版本: {serverVersion}，当前版本: {localVersion}");
                    btnStartUpdate.Enabled = true;
                }
                else
                {
                    // 没有新版本，显示提示消息
                    LogMessage("当前已是最新版本");

                    // 确保消息框显示在前面
                    this.TopMost = false;

                    MessageBox.Show($"当前版本 ({localVersion}) 已是最新版本，无需更新！",
                        "检查更新", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
            }
            catch (Exception ex)
            {
                // 显示错误信息
                LogMessage($"检查更新失败: {ex.Message}");

                // 确保消息框显示在前面
                this.TopMost = false;

                MessageBox.Show($"检查更新失败: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            finally
            {
                // 恢复按钮状态
                btnCheckUpdate.Enabled = true;
            }
        }

        /// <summary>
        /// 退出按钮点击事件
        /// </summary>
        private void btnExit_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }

        /// <summary>
        /// 切换显示详细日志和更新日志
        /// </summary>
        private void lnkShowLog_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            // 切换日志显示
            if (txtLog.Visible)
            {
                // 切换到更新日志
                txtLog.Visible = false;
                txtUpdateLog.Visible = true;
                lnkShowLog.Text = "显示详细日志";
            }
            else
            {
                // 切换到详细日志
                txtLog.Visible = true;
                txtUpdateLog.Visible = false;
                lnkShowLog.Text = "显示更新日志";
            }
        }
        #endregion

        #region 辅助方法
        /// <summary>
        /// 检查系统是否可用PowerShell
        /// </summary>
        /// <returns>是否可用PowerShell</returns>
        private bool IsPowerShellAvailable()
        {
            try
            {
                // 检查PowerShell是否可用
                using (Process process = new Process())
                {
                    process.StartInfo.FileName = "powershell.exe";
                    process.StartInfo.Arguments = "-Command \"exit\"";
                    process.StartInfo.UseShellExecute = false;
                    process.StartInfo.CreateNoWindow = true;
                    process.Start();
                    process.WaitForExit(1000);
                    return true;
                }
            }
            catch
            {
                // 如果执行失败，则认为PowerShell不可用
                return false;
            }
        }

        /// <summary>
        /// 获取文件的短路径名称，避免中文路径问题
        /// </summary>
        /// <param name="longPath">长路径</param>
        /// <returns>短路径</returns>
        private string GetShortPath(string longPath)
        {
            try
            {
                // 使用P/Invoke调用Windows API获取短路径名
                StringBuilder shortPathBuffer = new StringBuilder(260);
                int result = GetShortPathName(longPath, shortPathBuffer, shortPathBuffer.Capacity);
                if (result != 0)
                {
                    return shortPathBuffer.ToString();
                }
                else
                {
                    // 如果获取失败，返回原路径
                    return longPath;
                }
            }
            catch
            {
                // 出现异常时返回原路径
                return longPath;
            }
        }

        [System.Runtime.InteropServices.DllImport("kernel32.dll", CharSet = System.Runtime.InteropServices.CharSet.Auto)]
        private static extern int GetShortPathName(
            [System.Runtime.InteropServices.MarshalAs(System.Runtime.InteropServices.UnmanagedType.LPTStr)] string path,
            [System.Runtime.InteropServices.MarshalAs(System.Runtime.InteropServices.UnmanagedType.LPTStr)] StringBuilder shortPath,
            int shortPathLength);
        #endregion
    }

    /// <summary>
    /// 版本比较帮助类
    /// </summary>
    public static class VersionHelper
    {
        /// <summary>
        /// 比较两个版本号
        /// </summary>
        /// <param name="v1">版本号1</param>
        /// <param name="v2">版本号2</param>
        /// <returns>1:v1大于v2, 0:相等, -1:v1小于v2</returns>
        public static int CompareVersion(string v1, string v2)
        {
            // 如果本地版本未知，则认为需要更新
            if (string.IsNullOrEmpty(v2)) return 1;

            try
            {
                // 分割版本号
                string[] v1Parts = v1.Split('.');
                string[] v2Parts = v2.Split('.');

                // 比较每个部分
                int length = Math.Max(v1Parts.Length, v2Parts.Length);
                for (int i = 0; i < length; i++)
                {
                    int num1 = i < v1Parts.Length ? int.Parse(v1Parts[i]) : 0;
                    int num2 = i < v2Parts.Length ? int.Parse(v2Parts[i]) : 0;

                    if (num1 > num2) return 1;
                    if (num1 < num2) return -1;
                }

                return 0;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                // 如果解析出错，直接比较字符串
                return string.Compare(v1, v2);
            }
        }
    }

    /// <summary>
    /// 更新信息类
    /// </summary>
    public class UpdateInfo
    {
        /// <summary>
        /// 版本号
        /// </summary>
        public string Version { get; set; }

        /// <summary>
        /// 更新日志
        /// </summary>
        public string Changelog { get; set; }

        /// <summary>
        /// 下载地址
        /// </summary>
        public string DownloadUrl { get; set; }
    }
}
